home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / shadez.swf / scripts / Local / Game / Thing / CThingMain.as < prev    next >
Encoding:
Text File  |  2011-08-19  |  12.5 KB  |  400 lines

  1. package Local.Game.Thing
  2. {
  3.    import Local.*;
  4.    import Local.Game.World.*;
  5.    import Local.Game.World.Map.*;
  6.    import Local.Game.World.Map.Cell.*;
  7.    import flash.events.*;
  8.    import flash.geom.*;
  9.    
  10.    public class CThingMain extends CThingAffect
  11.    {
  12.       
  13.       public static const REACHEDOBJECTIVE:String = "REACHEDOBJECTIVE";
  14.       
  15.       public static var mFurthestMostEnemy:CThingMain;
  16.       
  17.       public static var mFurthestMostFriend:CThingMain;
  18.       
  19.       {
  20.          if(true)
  21.          {
  22.             REACHEDOBJECTIVE = "REACHEDOBJECTIVE";
  23.          }
  24.       }
  25.       
  26.       public var mCurrentTarget:CThingMain;
  27.       
  28.       public var mTargetAngle:CAngle;
  29.       
  30.       public var mTargetCloseRange:Number;
  31.       
  32.       public var mTargetAirbourne:Boolean;
  33.       
  34.       public var FILTER_Target:Function;
  35.       
  36.       internal var mWeaponDelta:CPosition;
  37.       
  38.       public var mTargetLOS:Boolean;
  39.       
  40.       public var mReachedObjective:Boolean;
  41.       
  42.       public var mTargetRange:Number;
  43.       
  44.       public var mDisposable:Boolean;
  45.       
  46.       public var mTargetRangeSQR:Number;
  47.       
  48.       public function CThingMain()
  49.       {
  50.          if(true)
  51.          {
  52.             super();
  53.          }
  54.       }
  55.       
  56.       public function get mBaseDamage() : Number
  57.       {
  58.          return 0;
  59.       }
  60.       
  61.       public function GetTargetRange(param1:CThingMain) : Number
  62.       {
  63.          return mPosition.Distance(param1.mPosition);
  64.       }
  65.       
  66.       public function Process_ReachedObjective() : Boolean
  67.       {
  68.          ┬º┬ºpush(mGroupID == GROUPID_FRIEND);
  69.          ┬º┬ºpush(mGroupID == GROUPID_FRIEND);
  70.          if(true)
  71.          {
  72.             if(┬º┬ºpop())
  73.             {
  74.                ┬º┬ºpop();
  75.                ┬º┬ºpush(mPosition.x > mLandscape.mWidth + 100);
  76.             }
  77.             if(┬º┬ºpop() || mGroupID == GROUPID_ENEMY && mPosition.x < -100)
  78.             {
  79.                mReachedObjective = true;
  80.                dispatchEvent(new Event(REACHEDOBJECTIVE));
  81.                DispatchDispose();
  82.                IncrementReachedObjective();
  83.                return true;
  84.             }
  85.             return false;
  86.          }
  87.          ┬º┬ºgoto(addr38);
  88.       }
  89.       
  90.       public function GetTarget() : CThingMain
  91.       {
  92.          var _loc1_:* = NaN;
  93.          var _loc2_:CCell = null;
  94.          var _loc3_:CThingMain = null;
  95.          if(true)
  96.          {
  97.             ┬º┬ºpush(Boolean(mCellCurrent));
  98.             if(true)
  99.             {
  100.                ┬º┬ºpush(┬º┬ºpop());
  101.                if(true)
  102.                {
  103.                   if(┬º┬ºpop())
  104.                   {
  105.                      if(true)
  106.                      {
  107.                         ┬º┬ºpop();
  108.                         if(true)
  109.                         {
  110.                            ┬º┬ºpush(mCellCurrent.mDumbCell);
  111.                            if(true)
  112.                            {
  113.                               addr37:
  114.                               if(┬º┬ºpop())
  115.                               {
  116.                                  if(true)
  117.                                  {
  118.                                     ┬º┬ºpush(null);
  119.                                     if(true)
  120.                                     {
  121.                                        return ┬º┬ºpop();
  122.                                     }
  123.                                  }
  124.                                  else
  125.                                  {
  126.                                     addr98:
  127.                                     if(_loc1_ > mFurthestMostFriend.mPosition.x)
  128.                                     {
  129.                                        addr104:
  130.                                        return null;
  131.                                     }
  132.                                     else
  133.                                     {
  134.                                        ┬º┬ºgoto(addr106);
  135.                                     }
  136.                                  }
  137.                                  return ┬º┬ºpop();
  138.                               }
  139.                               ┬º┬ºpush(mPosition.x + (mTargetRange + mBloatCellSearch) * mOrientation);
  140.                               if(true)
  141.                               {
  142.                                  _loc1_ = ┬º┬ºpop();
  143.                                  if(true)
  144.                                  {
  145.                                     if(mGroupID == GROUPID_FRIEND)
  146.                                     {
  147.                                        if(true)
  148.                                        {
  149.                                           ┬º┬ºpush(mFurthestMostEnemy == null);
  150.                                           if(true)
  151.                                           {
  152.                                              ┬º┬ºpush(┬º┬ºpop() || _loc1_ < mFurthestMostEnemy.mPosition.x);
  153.                                           }
  154.                                           if(!┬º┬ºpop())
  155.                                           {
  156.                                              addr81:
  157.                                              ┬º┬ºgoto(addr106);
  158.                                           }
  159.                                        }
  160.                                        return null;
  161.                                     }
  162.                                     if(mGroupID == GROUPID_ENEMY)
  163.                                     {
  164.                                        addr95:
  165.                                        ┬º┬ºpush(mFurthestMostFriend == null);
  166.                                        if(!(mFurthestMostFriend == null))
  167.                                        {
  168.                                           addr97:
  169.                                           ┬º┬ºpop();
  170.                                        }
  171.                                        ┬º┬ºgoto(addr98);
  172.                                     }
  173.                                     ┬º┬ºgoto(addr106);
  174.                                     ┬º┬ºgoto(addr106);
  175.                                  }
  176.                                  ┬º┬ºgoto(addr81);
  177.                               }
  178.                               ┬º┬ºgoto(addr98);
  179.                            }
  180.                            ┬º┬ºgoto(addr95);
  181.                         }
  182.                         ┬º┬ºgoto(addr104);
  183.                      }
  184.                      ┬º┬ºgoto(addr97);
  185.                   }
  186.                   ┬º┬ºgoto(addr37);
  187.                }
  188.                ┬º┬ºgoto(addr95);
  189.             }
  190.             ┬º┬ºgoto(addr98);
  191.          }
  192.          addr106:
  193.          for each(_loc2_ in mMap.GetCells(mPosition.x,_loc1_))
  194.          {
  195.             if(true)
  196.             {
  197.                var _loc6_:int = 0;
  198.                if(true)
  199.                {
  200.                   for each(_loc3_ in _loc2_.mMapwho)
  201.                   {
  202.                      if(false)
  203.                      {
  204.                         continue;
  205.                      }
  206.                      ┬º┬ºpush(_loc3_.mGroupID == mGroupID);
  207.                      if(!(_loc3_.mGroupID == mGroupID))
  208.                      {
  209.                         ┬º┬ºpop();
  210.                         if(true)
  211.                         {
  212.                            addr154:
  213.                            if(_loc3_.mCollide == null)
  214.                            {
  215.                               if(true)
  216.                               {
  217.                                  continue;
  218.                               }
  219.                            }
  220.                            else if(FILTER_Target(_loc3_))
  221.                            {
  222.                               if(ValidTarget(_loc3_))
  223.                               {
  224.                                  return _loc3_;
  225.                               }
  226.                               addr167:
  227.                               continue;
  228.                            }
  229.                            continue;
  230.                         }
  231.                         ┬º┬ºgoto(addr167);
  232.                      }
  233.                      ┬º┬ºgoto(addr154);
  234.                   }
  235.                }
  236.             }
  237.          }
  238.          return null;
  239.       }
  240.       
  241.       public function FILTER_AnyTarget(param1:CThingMain) : Boolean
  242.       {
  243.          return true;
  244.       }
  245.       
  246.       public function LineOfSight(param1:CThingMain) : Boolean
  247.       {
  248.          var _loc2_:CPosition = null;
  249.          var _loc3_:CPosition = null;
  250.          _loc2_ = mCollide.mMid;
  251.          _loc3_ = param1.mCollide.mMid;
  252.          return mLandscape.LineOfSight(_loc2_.x,_loc2_.y,_loc3_.x,_loc3_.y);
  253.       }
  254.       
  255.       public function ValidTarget(param1:CThingMain) : Boolean
  256.       {
  257.          if(true)
  258.          {
  259.             ┬º┬ºpush(param1.mDead);
  260.             ┬º┬ºpush(param1.mDead);
  261.             if(true)
  262.             {
  263.                if(!┬º┬ºpop())
  264.                {
  265.                   ┬º┬ºpop();
  266.                   if(true)
  267.                   {
  268.                      addr24:
  269.                      if(!param1.mInvisible)
  270.                      {
  271.                         if((param1.mPosition.x - mPosition.x) * mOrientation <= mTargetCloseRange)
  272.                         {
  273.                            if(true)
  274.                            {
  275.                               return false;
  276.                            }
  277.                         }
  278.                         else if(mPosition.DistanceSQR(param1.mPosition) <= mTargetRangeSQR)
  279.                         {
  280.                            addr63:
  281.                            ┬º┬ºpush(mTargetLOS);
  282.                            if(mTargetLOS)
  283.                            {
  284.                               ┬º┬ºpop();
  285.                               ┬º┬ºgoto(addr65);
  286.                            }
  287.                            addr76:
  288.                            if(┬º┬ºpop())
  289.                            {
  290.                               ┬º┬ºgoto(addr77);
  291.                            }
  292.                            else
  293.                            {
  294.                               ┬º┬ºgoto(addr79);
  295.                            }
  296.                         }
  297.                         return false;
  298.                      }
  299.                      if(true)
  300.                      {
  301.                         return false;
  302.                      }
  303.                      addr65:
  304.                      ┬º┬ºpush(!LineOfSight(param1));
  305.                      ┬º┬ºgoto(addr76);
  306.                   }
  307.                   addr77:
  308.                   return false;
  309.                }
  310.                ┬º┬ºgoto(addr24);
  311.             }
  312.             ┬º┬ºgoto(addr63);
  313.          }
  314.          addr79:
  315.          return true;
  316.       }
  317.       
  318.       public function get mSmallPrize() : int
  319.       {
  320.          return 0;
  321.       }
  322.       
  323.       public function DispatchDispose() : void
  324.       {
  325.          mInvisible = true;
  326.          Process = Process_DisposeShotEffect;
  327.       }
  328.       
  329.       public function FILTER_AirTargets(param1:CThingMain) : Boolean
  330.       {
  331.          return param1.mTargetAirbourne;
  332.       }
  333.       
  334.       public function get mPrize() : int
  335.       {
  336.          return 0;
  337.       }
  338.       
  339.       private function Process_DisposeShotEffect() : void
  340.       {
  341.          var _loc1_:* = 0;
  342.          var _loc2_:* = undefined;
  343.          ┬º┬ºpush(0);
  344.          if(true)
  345.          {
  346.             _loc1_ = ┬º┬ºpop();
  347.             ┬º┬ºpush(0);
  348.          }
  349.          for each(_loc2_ in mChildren)
  350.          {
  351.             if(false)
  352.             {
  353.                continue;
  354.             }
  355.             ┬º┬ºpush(Boolean(_loc2_.mDisposable));
  356.             if(Boolean(_loc2_.mDisposable))
  357.             {
  358.                ┬º┬ºpop();
  359.                if(true)
  360.                {
  361.                   addr50:
  362.                   if(!Boolean(_loc2_.Process))
  363.                   {
  364.                      continue;
  365.                   }
  366.                   _loc2_.Process();
  367.                }
  368.                _loc1_++;
  369.                continue;
  370.             }
  371.             ┬º┬ºgoto(addr50);
  372.          }
  373.          if(_loc1_ == 0)
  374.          {
  375.             Dispose();
  376.          }
  377.       }
  378.       
  379.       public function FILTER_GroundTargets(param1:CThingMain) : Boolean
  380.       {
  381.          ┬º┬ºpush(param1.mTargetAirbourne);
  382.          if(true)
  383.          {
  384.             ┬º┬ºpush(!┬º┬ºpop());
  385.          }
  386.          return ┬º┬ºpop();
  387.       }
  388.       
  389.       public function SetTargetting(param1:Number, param2:Boolean, param3:Function, param4:Boolean = true, param5:Number = 0) : void
  390.       {
  391.          mTargetRange = param1;
  392.          mTargetCloseRange = param5;
  393.          mTargetRangeSQR = mTargetRange * mTargetRange;
  394.          mTargetAirbourne = param2;
  395.          mTargetLOS = param4;
  396.          FILTER_Target = param3;
  397.       }
  398.    }
  399. }
  400.